import store from '@/store'
import nedb from '@/db/nedb'
import { Message } from 'element-ui'

function taskResultMap(msg) {
    let mj = JSON.parse(msg.message)
    switch (mj.TaskType) {
        // 添加好友结果 ok
        case 'AddFriendsTask':
            addFriendsTaskHandle(mj)
            break
        // 停止清理僵尸粉 ok
        case 'PostStopFriendDetectTask':
            PostStopFriendDetectTaskHandle(mj)
            break
        // 删除朋友圈结果 ok
        case 'DeleteSNSNewsTask':
            deleteSNSNewsTaskHandle(mj)
            break
        // 朋友圈点赞结果通知 ok
        case 'CircleLikeTask':
            circleLikeTaskHandle(mj)
            break
        // 群发好友结果通知 ok
        case 'WeChatGroupSendTask':
            weChatGroupSendTaskHandle(mj)
            break
        // 修改备注 ok
        case 'ModifyFriendMemoTask':
            modifyFriendMemoTaskHandle(mj)
            break
        // 标签的操作 ok
        case 'ContactLabelTask':
            contactLabelTaskHandle(mj)
            break
        // 群管理结果通知 ok
        case 'ChatRoomActionTask':
            chatRoomActionTaskHandle(mj)
            break
        // 群加好友结果通知
        case 'AddFriendInChatRoomTask':
            addFriendInChatRoomTaskHandle(mj)
            break

        // 获取图片/视频/文件url
        case 'RequestTalkDetailTask':
            requestTalkDetailTaskHandle(mj)
            break
        // 发红包结果通知
        case 'SendLuckyMoneyTask':
            sendLuckyMoneyTaskHandle(mj)
            break
        // 转账结果通知
        case 'RemittanceTask':
            remittanceTaskHandle(mj)
            break

        // 好友删除任务结果通知
        case 'DeleteFriendTask':
            deleteFriendTaskHandle(mj)
            break
        // 同意进群任务结果
        case 'AgreeJoinChatRoomTask':
            agreeJoinChatRoomTaskHandle(mj)
            break
        // 消息撤回通知
        case 'RevokeMessageTask':
            revokeMessageTaskHandle(mj)
            break
        // 消息撤回通知
        case 'PhoneActionTask':
            phoneActionTaskHandle(mj)
            break
        default:
            break
    }
}

// 添加好友通知 ok
function addFriendsTaskHandle(mj) {
    let result = mj.Success ? '已申请' : mj.ErrMsg
    mj.result = result
    mj.TaskId = Number(mj.TaskId)
    store.dispatch('nedb/AddOrUpdateAddFriends', mj)
}

// 停止清理僵尸粉通知 ok
function PostStopFriendDetectTaskHandle(mj) {
    if (mj.Success) {
        Message({
            type: 'success',
            message: '停止清理僵尸粉成功！',
            duration: 1000
        })
    } else {
        Message({
            type: 'warning',
            message: '停止清理僵尸粉失败！',
            duration: 2000
        })
    }
}

// 手机管理 未添加逻辑 需要的自己添加 ok
function phoneActionTaskHandle(mj) {
    if (mj.Success) {
        Message({
            type: 'success',
            message: '任务执行成功！',
            duration: 1000
        })
    } else {
        Message({
            type: 'warning',
            message: '任务执行失败！',
            duration: 2000
        })
    }
    // 如果输出更详细的信息 需要把任务存数据库
}

// 群发好友结果通知 ok
function weChatGroupSendTaskHandle(mj) {
    if (mj.Success) {
        Message({
            type: 'success',
            message: '群发成功！',
            duration: 1000
        })
    } else {
        Message({
            type: 'warning',
            message: '群发失败！',
            duration: 2000
        })
    }
    // 更新数据库
    store.dispatch('nedb/UpdateGroupSendTask', mj)
}

// 删除朋友圈结果通知 ok
function deleteSNSNewsTaskHandle(mj) {
    if (mj.Success) {
        Message({
            type: 'success',
            message: '删除朋友圈成功！',
            duration: 1000
        })
    } else {
        Message({
            type: 'warning',
            message: '删除朋友圈失败！',
            duration: 2000
        })
    }
    store.dispatch('nedb/UpdateCircleTask', mj)
}

// 朋友圈点赞 ok
function circleLikeTaskHandle(mj) {
    nedb.circleTask.findOne({ TaskId: mj.TaskId }, (err, doc) => {
        if (err || !doc) return
        let friendId = doc.FriendId || doc.WeChatId
        if (mj.Success && doc.IsCancel) {
            Message({
                type: 'success',
                message: '取消点赞成功！',
                duration: 1000
            })
            // 更新本地数据库 效率高 代码写起来麻烦
            nedb.circles.findOne(
                { WeChatId: doc.WeChatId, FriendId: friendId },
                (err, cdoc) => {
                    for (const circle of cdoc.Circles) {
                        if (circle.CircleId === doc.CircleId) {
                            let likes = []
                            for (const like of circle.Likes) {
                                if (like.FriendId !== mj.WeChatId) {
                                    likes.push(like)
                                }
                            }
                            circle.Likes = likes
                            let newCircles = {
                                WeChatId: doc.WeChatId,
                                Circles: [circle]
                            }
                            store.dispatch('nedb/UpdateOrAddCircles', newCircles)
                            break
                        }
                    }
                })
            // 或者 调用刷新该朋友圈的接口 但是效率比较低
            // store.dispatch('websocket/TriggerCirclePushTask', doc)
        } else if (mj.Success && !doc.IsCancel) {
            Message({
                type: 'success',
                message: '点赞成功！',
                duration: 1000
            })
            // 更新本地数据库
            nedb.circles.findOne(
                { WeChatId: doc.WeChatId, FriendId: friendId },
                (err, cdoc) => {
                    for (const circle of cdoc.Circles) {
                        if (circle.CircleId === doc.CircleId) {
                            let like = {
                                FriendId: doc.WeChatId,
                                PublishTime: parseInt(new Date().getTime() / 1000, 10)
                            }
                            if (circle.Likes) {
                                circle.Likes.push(like)
                            } else {
                                circle.Likes = [like]
                            }
                            let newCircles = {
                                WeChatId: doc.WeChatId,
                                Circles: [circle]
                            }
                            store.dispatch('nedb/UpdateOrAddCircles', newCircles)
                            break
                        }
                    }
                })
            // 刷新该朋友圈
            // store.dispatch('websocket/TriggerCirclePushTask', doc)
        } else if (!doc.IsCancel) {
            Message({
                type: 'warning',
                message: '点赞失败！',
                duration: 2000
            })
        } else {
            Message({
                type: 'warning',
                message: '取消点赞失败！',
                duration: 2000
            })
        }
        // 更新朋友圈任务表
        store.dispatch('nedb/UpdateCircleTask', mj)
    })
}

// 备注相关的操作 ok
function modifyFriendMemoTaskHandle(mj) {
    // 更新任务列表
    store.dispatch('nedb/UpdateMemoTask', mj)
    let taskId = mj.TaskId
    // let wechatId = mj.WeChatId
    if (mj.Success) {
        Message({
            type: 'success',
            message: '设置备注和标签任务成功！',
            duration: 1000
        })
        // 修改本地的好友数据
        nedb.memoTask.findOne({ TaskId: taskId }, (err, doc) => {
            if (err) return
            if (doc) {
                nedb.friends.findOne(
                    { userId: doc.userId, WeChatId: doc.WeChatId, FriendId: doc.FriendId },
                    (err, friend) => {
                        if (err) return
                        if (friend) {
                            // 1 删除备注 2 删除描述 4 删除号码
                            if (doc.DelFlag) {
                                switch (doc.DelFlag) {
                                    case 1:
                                        friend.Memo = ''
                                        break;
                                    case 2:
                                        friend.Desc = ''
                                        break;
                                    case 4:
                                        friend.Phone = ''
                                        break;
                                    default:
                                        break;
                                }
                            } else {
                                if (doc.Memo) {
                                    friend.Memo = doc.Memo
                                }
                                if (doc.Phone) {
                                    friend.Phone = doc.Phone + '，'
                                }
                                if (doc.Desc) {
                                    friend.Desc = doc.Desc
                                }
                            }
                            // 更新friends数据库
                            store.dispatch('nedb/UpdateFriends', friend)
                            // 更新currentFriends
                            store.dispatch('conversation/UpdateCurrentFriends', friend)
                        }
                    })
            }
        })
    } else {
        Message({
            type: 'warning',
            message: '设置备注和标签任务失败！',
            duration: 2000
        })
    }

}

// 标签的操作 ok
function contactLabelTaskHandle(mj) {
    // 更新本地打标签任务表
    store.dispatch('nedb/UpdateMemoTask', mj)
    console.log('更新本地打标签任务表', mj)
    if (mj.Success) {
        Message({
            type: 'success',
            message: '标签任务成功！',
            duration: 1000
        })
        // 修改本地的好友数据
        nedb.memoTask.findOne({ TaskId: mj.TaskId }, (err, doc) => {
            if (err) return
            if (doc) {
                let friendId = doc.AddList || doc.DelList
                nedb.friends.findOne(
                    { userId: doc.userId, WeChatId: doc.WeChatId, FriendId: friendId },
                    (err, friend) => {
                        if (err) return
                        if (friend) {
                            if (doc.AddList) {
                                if (doc.LabelId) {
                                    friend.LabelIds = friend.LabelIds + ',' + doc.LabelId
                                } else {
                                    let requesMsg = {
                                        wechatId: friend.WeChatId,
                                        friendId: friend.FriendId
                                    }
                                    store.dispatch('websocket/RequestContactsInfoTask', requesMsg)
                                }
                            } else if (doc.DelList) {
                                if (friend.LabelIds) {
                                    friend.LabelIds = friend.LabelIds.replace(new RegExp(doc.LabelId + ',', 'g'), '')
                                    friend.LabelIds = friend.LabelIds.replace(new RegExp(doc.LabelId, 'g'), '')
                                    friend.LabelIds = friend.LabelIds.replace(/,$/, '')
                                }
                            }
                            // 更新friends数据库
                            store.dispatch('nedb/UpdateFriends', friend)
                            // 更新currentFriends
                            store.dispatch('conversation/UpdateCurrentFriends', friend)
                        }
                    })
            }
        })
    } else {
        Message({
            type: 'warning',
            message: '添加或删除标签任务失败！',
            duration: 2000
        })
    }
}

// 群管理结果通知 ing
function chatRoomActionTaskHandle(message) {
    // 更新本地群聊任务表
    store.dispatch('nedb/UpdateChatRoomTask', message)
    nedb.chatRoomTask.findOne(
        { taskId: message.TaskId },
        (err, doc) => {
            if (err) return
            if (doc) {
                let action = doc.Action
                let actionMap = {
                    0: '修改群名称',
                    1: '修改群公告',
                    2: '拉人进群',
                    3: '踢人',
                    4: '修改群内显示名',
                    5: '设置保存到通讯',
                    6: '设置消息免打扰',
                    7: '删除并退出群',
                    8: '建群',
                    9: '查看所有群成员',
                    10: '群主转让',
                    11: '设置群邀请确认',
                }

                if (message.Success) {
                    Message({
                        type: 'success',
                        message: `${actionMap[action]}成功！`,
                        duration: 1000
                    })
                } else {
                    Message({
                        type: 'warning',
                        message: `${actionMap[action]}失败！${message.ErrMsg}`,
                        duration: 2000
                    })
                }

                switch (action) {
                    case 5:
                        //   let msg5 = ''
                        //   if (doc.IntValue === 0) {
                        //     msg5 = '关闭保存到通讯成功'
                        //   } else {
                        //     msg5 = '打开保存到通讯成功'
                        //   }
                        //   if (flag === 1) {
                        //     nedb.chatRoomConfig.update(
                        //       {
                        //         userId: userId,
                        //         WeChatId: doc.WeChatId,
                        //         ChatRoomId: doc.ChatRoomId
                        //       },
                        //       {
                        //         $set: {
                        //           userId: userId,
                        //           WeChatId: doc.WeChatId,
                        //           ChatRoomId: doc.ChatRoomId,
                        //           SaveToAddress: doc.IntValue
                        //         }
                        //       },
                        //       { upsert: true },
                        //       (err, numReplaced) => {
                        //       }
                        //     )
                        //   } else {
                        //     store.dispatch('SetError', {
                        //       ErrorCode: `${msg5}`,
                        //       ErrorMsg: message.ErrMsg
                        //     })
                        //     store.dispatch('SetDialog', 'ErrorPage')
                        //   }
                        break
                    case 6:
                        //   let msg6 = ''
                        //   if (doc.IntValue === 1) {
                        //     msg6 = '关闭消息免打扰成功'
                        //   } else {
                        //     msg6 = '打开消息免打扰成功'
                        //   }
                        //   if (flag === 1) {
                        //     nedb.chatRoomConfig.update(
                        //       {
                        //         userId: userId,
                        //         WeChatId: doc.WeChatId,
                        //         ChatRoomId: doc.ChatRoomId
                        //       },
                        //       {
                        //         $set: {
                        //           userId: userId,
                        //           WeChatId: doc.WeChatId,
                        //           ChatRoomId: doc.ChatRoomId,
                        //           DoNotTouch: doc.IntValue
                        //         }
                        //       },
                        //       { upsert: true },
                        //       (err, numReplaced) => {
                        //       }
                        //     )
                        //   } else {
                        //     store.dispatch('SetError', {
                        //       ErrorCode: `${msg6}`,
                        //       ErrorMsg: message.ErrMsg
                        //     })
                        //     store.dispatch('SetDialog', 'ErrorPage')
                        //   }
                        break
                    case 11:
                        //   let msg11 = ''
                        //   if (doc.IntValue === 0) {
                        //     msg11 = '关闭群邀请确认'
                        //   } else {
                        //     msg11 = '打开群邀请确认'
                        //   }
                        //   if (flag === 1) {
                        //     nedb.chatRoomConfig.update(
                        //       {
                        //         userId: userId,
                        //         WeChatId: doc.WeChatId,
                        //         ChatRoomId: doc.ChatRoomId
                        //       },
                        //       {
                        //         $set: {
                        //           userId: userId,
                        //           WeChatId: doc.WeChatId,
                        //           ChatRoomId: doc.ChatRoomId,
                        //           SetInvitationConfirm: doc.IntValue
                        //         }
                        //       },
                        //       { upsert: true },
                        //       (err, numReplaced) => {
                        //       }
                        //     )
                        //   } else {
                        //     store.dispatch('SetError', {
                        //       ErrorCode: `${msg11}`,
                        //       ErrorMsg: message.ErrMsg
                        //     })
                        //     store.dispatch('SetDialog', 'ErrorPage')
                        //   }
                        break
                    default:
                        break
                }
            }
        })
}

// 加群成员为好友 ok
function addFriendInChatRoomTaskHandle(message) {
    // 更新本地群聊任务表
    store.dispatch('nedb/UpdateChatRoomTask', message)
    if (message.Success) {
        Message({
            type: 'success',
            message: '添加群成员到通讯录成功！',
            duration: 1000
        })
    } else {
        Message({
            type: 'warning',
            message: '添加群成员到通讯录失败！',
            duration: 2000
        })
    }
}

// 发红包结果通知 ok
function sendLuckyMoneyTaskHandle(message) {
    if (message.Success) {
        // 发红包没有返回MsgSvrId 而是返回了SendId
        message.MsgSvrId = message.ErrMsg
        // 发红包没有返回MsgId 而是返回了TaskId
        message.MsgId = message.TaskId
        Message({
            type: 'success',
            message: '红包发送成功！',
            duration: 1000
        })
        nedb.chats.findOne({ MsgId: message.MsgId }, (err, doc) => {
            if (doc) {
                message.FriendId = doc.FriendId
                store.dispatch('nedb/UpdateChats', message)
            }
        })
    } else {
        Message({
            type: 'warning',
            message: `红包发送失败`,
            duration: 2000,
        })
    }
}

// 转账结果 ok
function remittanceTaskHandle(message) {
    if (message.Success) {
        // 发红包没有返回MsgSvrId 而是返回了SendId
        message.MsgSvrId = message.ErrMsg
        // 发红包没有返回MsgId 而是返回了TaskId
        message.MsgId = message.TaskId
        Message({
            type: 'success',
            message: '转账成功！',
            duration: 1000
        })
        nedb.chats.findOne({ MsgId: message.MsgId }, (err, doc) => {
            if (doc) {
                message.FriendId = doc.FriendId
                store.dispatch('nedb/UpdateChats', message)
            }
        })
    } else {
        Message({
            type: 'warning',
            message: `转账失败`,
            duration: 2000,
        })
    }
}

// 删除好友结果处理 ok
function deleteFriendTaskHandle(message) {
    if (message.Success) {
        Message({
            type: 'success',
            message: '删除好友成功！',
            duration: 1000
        })
        // 删除成功之后的逻辑
        // 这里删除成功之后会触发FriendDelNotice，逻辑在哪里处理
    } else {
        Message({
            type: 'warning',
            message: '删除好友失败！',
            duration: 2000
        })
    }
}

// 消息撤回结果通知 ok
function revokeMessageTaskHandle(message) {
    if (message.Success) {
        Message({
            type: 'success',
            message: '消息撤回成功！',
            duration: 1000
        })
        store.dispatch('nedb/SetChatRevoked', message)
    } else {
        Message({
            type: 'warning',
            message: '消息撤回失败',
            duration: 2000
        })
    }
}

// 获取大图失败处理 ok
function requestTalkDetailTaskHandle(message) {
    // let message = JSON.parse(msg.message)
    // "{
    //   "Code": "InternalError",
    //   "ErrMsg": "no this msg",
    //   "TaskId": "15713640375213592",
    //   "TaskType": "RequestTalkDetailTask",
    //   "WeChatId": "wxid_rhejjjajt0p22"
    // }"
    if (message.ErrMsg) {
        Message({
            type: 'warning',
            message: '获取详情失败' + message.ErrMsg,
            duration: 2000
        })
    }
}

// 同意进群 ok
function agreeJoinChatRoomTaskHandle(message) {
    if (message.Success) {
        Message({
            type: 'success',
            message: '加入群聊成功！',
            duration: 1000
        })
    } else {
        Message({
            type: 'warning',
            message: '加入群聊失败！',
            duration: 2000
        })
    }
}

export default {
    taskResultMap
}
